home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 98 / Skunkware 98.iso / src / net / omniORB-2.5.0-src.tar.gz / omniORB-2.5.0-src.tar / omniORB_2.5.0 / include / omniORB2 / templates.h < prev   
C/C++ Source or Header  |  1998-03-09  |  27KB  |  936 lines
  1. // -*- Mode: C++; -*-
  2. //                            Package   : omniORB2
  3. // templates.h                Created on: 14/5/96
  4. //                            Author    : Sai Lai Lo (sll)
  5. //
  6. //    Copyright (C) 1996, 1997 Olivetti & Oracle Research Laboratory
  7. //
  8. //    This file is part of the omniORB library
  9. //
  10. //    The omniORB library is free software; you can redistribute it and/or
  11. //    modify it under the terms of the GNU Library General Public
  12. //    License as published by the Free Software Foundation; either
  13. //    version 2 of the License, or (at your option) any later version.
  14. //
  15. //    This library is distributed in the hope that it will be useful,
  16. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18. //    Library General Public License for more details.
  19. //
  20. //    You should have received a copy of the GNU Library General Public
  21. //    License along with this library; if not, write to the Free
  22. //    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  
  23. //    02111-1307, USA
  24. //
  25. //
  26. // Description:
  27. //       *** PROPRIETORY INTERFACE ***
  28.  
  29. /*
  30.   $Log: templates.h,v $
  31.  * Revision 1.15  1998/03/09  17:15:33  ewc
  32.  * New NP_getSlice() function in _Forany template.
  33.  *
  34.  * Revision 1.14  1998/03/05  11:20:21  sll
  35.  * Backoff previous change to Sequence_Array_Var.
  36.  *
  37.   Revision 1.13  1998/03/04 15:07:50  ewc
  38.   Small bug fix to Sequence_Var types
  39.  
  40.  * Revision 1.12  1998/03/04  14:48:34  sll
  41.  * Disambiguous reference to NP_data() by adding the _CORBA_Sequence<T>::
  42.  * prefix.
  43.  *
  44.  * Revision 1.11  1998/01/27  16:11:06  ewc
  45.  * Added support for type any.
  46.  *
  47.   Revision 1.10  1997/12/23 19:37:57  sll
  48.   Removed const T* conversion operator in _CORBA_Array_Var as it is causing
  49.   conversion ambiguity.
  50.   Demote workarounds for older DEC C++ compiler as the bug has been fixed.
  51.  
  52.   Revision 1.9  1997/12/09 20:41:02  sll
  53.   Updated sequence array templates.
  54.  
  55.   Revision 1.8  1997/08/21 22:22:45  sll
  56.   New templates for sequence of array.
  57.  
  58.  * Revision 1.7  1997/05/06  16:11:33  sll
  59.  * Public release.
  60.  *
  61.   */
  62.  
  63. #ifndef __TEMPLATES_H__
  64. #define __TEMPLATES_H__
  65.  
  66. class NetBufferedStream;
  67. class MemBufferedStream;
  68.  
  69.  
  70. template <class T,class T_Helper>
  71. class _CORBA_ObjRef_Member;
  72.  
  73. template <class T,class T_var,class T_member>
  74. class _CORBA_ObjRef_INOUT_arg;
  75.  
  76. template <class T,class T_var,class T_member,class T_Helper>
  77. class _CORBA_ObjRef_OUT_arg;
  78.  
  79. template <class T,class T_Helper>
  80. class _CORBA_ObjRef_Var {
  81. public:
  82.   typedef T* ptr_t;
  83.   inline _CORBA_ObjRef_Var() { pd_objref = T_Helper::_nil(); }
  84.   inline _CORBA_ObjRef_Var(T *p) { pd_objref = p; }
  85.   inline ~_CORBA_ObjRef_Var() { 
  86. #if !defined(__DECCXX) || (__DECCXX_VER >= 50500000)
  87.     if (!T_Helper::is_nil(pd_objref)) T_Helper::release(pd_objref);
  88. #else
  89.     if (!CORBA::is_nil(pd_objref)) CORBA::release(pd_objref);
  90. #endif
  91.   }
  92.   inline _CORBA_ObjRef_Var(const _CORBA_ObjRef_Var<T,T_Helper> &p);
  93.   inline _CORBA_ObjRef_Var(const _CORBA_ObjRef_Member<T,T_Helper>&);
  94.   inline _CORBA_ObjRef_Var<T,T_Helper> &operator= (T * p);
  95.   inline _CORBA_ObjRef_Var<T,T_Helper> &operator= (const _CORBA_ObjRef_Var<T,T_Helper> &p);
  96.  inline _CORBA_ObjRef_Var<T,T_Helper> &operator= (const _CORBA_ObjRef_Member<T,T_Helper>&);
  97.   inline T* operator->() const { return (T*) pd_objref; }
  98.  
  99.   inline operator T* () const { return pd_objref; }
  100.  
  101.   friend class _CORBA_ObjRef_Member<T,T_Helper>;
  102.   friend class _CORBA_ObjRef_INOUT_arg<T,
  103.                                        _CORBA_ObjRef_Var<T,T_Helper>,
  104.                                        _CORBA_ObjRef_Member<T,T_Helper> >;
  105.   friend class _CORBA_ObjRef_OUT_arg<T,
  106.                                      _CORBA_ObjRef_Var<T,T_Helper>,
  107.                                      _CORBA_ObjRef_Member<T,T_Helper>,
  108.                                      T_Helper>;
  109.   
  110. private:
  111.   T* pd_objref;
  112. };
  113.  
  114. template <class T,class T_Helper>
  115. class _CORBA_ObjRef_Member {
  116. public:
  117.   inline _CORBA_ObjRef_Member() { _ptr = T_Helper::_nil(); }
  118.   inline _CORBA_ObjRef_Member(T *p) { _ptr = p; }
  119.   inline _CORBA_ObjRef_Member(const _CORBA_ObjRef_Member<T,T_Helper> &p);
  120.   inline ~_CORBA_ObjRef_Member() { 
  121. #if !defined(__DECCXX) || (__DECCXX_VER >= 50500000)
  122.     if (!T_Helper::is_nil(_ptr)) T_Helper::release(_ptr);
  123. #else
  124.     if (!CORBA::is_nil(_ptr)) CORBA::release(_ptr);
  125. #endif
  126.   }
  127.   inline _CORBA_ObjRef_Member<T,T_Helper> &operator= (T * p);
  128.   inline _CORBA_ObjRef_Member<T,T_Helper> &operator= (const _CORBA_ObjRef_Member<T,T_Helper> &p);
  129.   inline _CORBA_ObjRef_Member<T,T_Helper> &operator= (const _CORBA_ObjRef_Var<T,T_Helper> &p);
  130.  
  131.   inline T* operator->() const { return (T*)_ptr; }
  132.  
  133.   inline size_t NP_alignedSize(size_t initialoffset) const;
  134.   inline void operator>>= (NetBufferedStream &s) const;
  135.   inline void operator<<= (NetBufferedStream &s);
  136.   inline void operator>>= (MemBufferedStream &s) const;
  137.   inline void operator<<= (MemBufferedStream &s);
  138.  
  139.   // The following conversion operators are needed to support the
  140.   // implicit conversion from this type to its T* data member.
  141.   // They are used when this type is used as the rvalue of an expression.
  142.   inline operator T* () const { return _ptr; }
  143.  
  144.   T *_ptr;
  145. };
  146.  
  147. template <class T,class T_var,class T_member>
  148. class _CORBA_ObjRef_INOUT_arg {
  149. public:
  150.   inline _CORBA_ObjRef_INOUT_arg(T*& p) : _data(p) {}
  151.   inline _CORBA_ObjRef_INOUT_arg(T_var& p) : _data(p.pd_objref) {}
  152.   inline _CORBA_ObjRef_INOUT_arg(T_member& p) : _data(p._ptr) {}
  153.   T*& _data;
  154. private:
  155.   _CORBA_ObjRef_INOUT_arg();
  156. };
  157.  
  158. template <class T,class T_var,class T_member,class T_Helper>
  159. class _CORBA_ObjRef_OUT_arg {
  160. public:
  161.   inline _CORBA_ObjRef_OUT_arg(T*& p) : _data(p) {}
  162.   inline _CORBA_ObjRef_OUT_arg(T_var& p) : _data(p.pd_objref) {
  163.     p = T_Helper::_nil();
  164.   }
  165.   inline _CORBA_ObjRef_OUT_arg(T_member& p) : _data(p._ptr) {
  166.     p = T_Helper::_nil();
  167.   }
  168.   T*& _data;
  169. private:
  170.   _CORBA_ObjRef_OUT_arg();
  171. };
  172.  
  173.  
  174. template <class T>
  175. class _CORBA_ConstrType_Fix_Var {
  176. public:
  177.   inline _CORBA_ConstrType_Fix_Var() { }
  178.   inline _CORBA_ConstrType_Fix_Var(T* p) { pd_data = *p; delete p; }
  179.   inline _CORBA_ConstrType_Fix_Var(const _CORBA_ConstrType_Fix_Var<T> &p) {
  180.     pd_data = p.pd_data;
  181.   }
  182.   inline ~_CORBA_ConstrType_Fix_Var() {  }
  183.   inline _CORBA_ConstrType_Fix_Var<T> &operator= (T* p) {
  184.     pd_data = *p;
  185.     delete p;
  186.     return *this;
  187.   }
  188.   inline _CORBA_ConstrType_Fix_Var<T> &operator= (const _CORBA_ConstrType_Fix_Var<T> &p) {
  189.     pd_data = p.pd_data;
  190.     return *this;
  191.   }
  192.   inline _CORBA_ConstrType_Fix_Var<T> &operator= (T p) {
  193.     pd_data = p;
  194.     return *this;
  195.   }
  196.   inline T* operator->() const { return (T*) &pd_data; }
  197.  
  198. #if defined(__GNUG__) && __GNUG__ == 2 && __GNUC_MINOR__ == 7
  199.   inline operator T& () const { return (T&)pd_data; }
  200. #else
  201.   inline operator const T& () const { return pd_data; }
  202.   inline operator T& () { return pd_data; }
  203. #endif
  204.   // This conversion operator is necessary to support the implicit conversion
  205.   // when this var type is used as the IN or INOUT argument of an operation.
  206.  
  207.   // The following coversion operators are needed to support the casting
  208.   // of this var type to a const T* or a T*. The CORBA spec. doesn't say
  209.   // these castings must be supported so they are deliberately left out.
  210.   // In fact, the operator->() can always be used to get to the T*.
  211.   //
  212.   // inline operator const T* () const { return pd_data; }
  213.   // inline operator T* () { return pd_data; }
  214.  
  215. private:
  216.   T pd_data;
  217. };
  218.  
  219. template <class T,class T_var>
  220. class _CORBA_ConstrType_Variable_OUT_arg;
  221.  
  222. template <class T>
  223. class _CORBA_ConstrType_Variable_Var {
  224. public:
  225.   inline _CORBA_ConstrType_Variable_Var() { pd_data = 0; }
  226.   inline _CORBA_ConstrType_Variable_Var(T* p) { pd_data = p; }
  227.   inline _CORBA_ConstrType_Variable_Var(const _CORBA_ConstrType_Variable_Var<T> &p);
  228.   inline ~_CORBA_ConstrType_Variable_Var() {  if (pd_data) delete pd_data; }
  229.   inline _CORBA_ConstrType_Variable_Var<T> &operator= (T* p);
  230.   inline _CORBA_ConstrType_Variable_Var<T> &operator= (const _CORBA_ConstrType_Variable_Var<T> &p);
  231.   inline T* operator->() const { return (T*)pd_data; }
  232.  
  233. #if defined(__GNUG__) && __GNUG__ == 2 && __GNUC_MINOR__ == 7
  234.   inline operator T& () const { return (T&) *pd_data; }
  235. #else
  236.   inline operator const T& () const { return *pd_data; }
  237.   inline operator T& () { return *pd_data; }
  238. #endif
  239.   // This conversion operator is necessary to support the implicit conversion
  240.   // when this var type is used as the IN or INOUT argument of an operation.
  241.  
  242.   // The following coversion operators are needed to support the casting
  243.   // of this var type to a const T* or a T*. The CORBA spec. doesn't say
  244.   // these castings must be supported so they are deliberately left out.
  245.   // In fact, the operator->() can always be used to get to the T*.
  246.   //
  247.   // inline operator const T* () const { return pd_data; }
  248.   // inline operator T* () { return pd_data; }
  249.  
  250.   friend class _CORBA_ConstrType_Variable_OUT_arg<T,_CORBA_ConstrType_Variable_Var<T> >;
  251. private:
  252.   T* pd_data;
  253. };
  254.  
  255.  
  256. template <class T, class T_var>
  257. class _CORBA_ConstrType_Variable_OUT_arg {
  258. public:
  259.   inline _CORBA_ConstrType_Variable_OUT_arg(T*& p) : _data(p) {}
  260.   inline _CORBA_ConstrType_Variable_OUT_arg(T_var& p) : _data(p.pd_data) {
  261.     p = (T*)0;
  262.   }
  263.   T*& _data;
  264. private:
  265.   _CORBA_ConstrType_Variable_OUT_arg();
  266. };
  267.  
  268.  
  269. template <class T,class T_var>
  270. class _CORBA_Sequence_OUT_arg;
  271.  
  272. template <class T,class ElmType>
  273. class _CORBA_Sequence_Var {
  274. public:
  275.   typedef T* ptr_t;
  276.   inline _CORBA_Sequence_Var() { pd_data = 0; }
  277.   inline _CORBA_Sequence_Var(T* p) { pd_data = p; }
  278.   inline _CORBA_Sequence_Var(const _CORBA_Sequence_Var<T,ElmType> &p);
  279.   inline ~_CORBA_Sequence_Var() {  if (pd_data) delete pd_data; }
  280.   inline _CORBA_Sequence_Var<T,ElmType> &operator= (T* p);
  281.   inline _CORBA_Sequence_Var<T,ElmType> &operator= (const _CORBA_Sequence_Var<T,ElmType> &p);
  282.   inline ElmType &operator[] (_CORBA_ULong index) { return (pd_data->_CORBA_Sequence<ElmType>::NP_data())[index]; }
  283.   inline const ElmType &operator[] (_CORBA_ULong index) const {
  284.     return (pd_data->_CORBA_Sequence<ElmType>::NP_data())[index];
  285.   }
  286.   inline T* operator->() const { return (T*)pd_data; }
  287.  
  288. #if defined(__GNUG__) && __GNUG__ == 2 && __GNUC_MINOR__ == 7
  289.   inline operator T& () const { return *pd_data; }
  290. #else
  291.   inline operator const T& () const { return *pd_data; }
  292.   inline operator T& () { return *pd_data; }
  293. #endif
  294.   // This conversion operator is necessary to support the implicit conversion
  295.   // when this var type is used as the IN or INOUT argument of an operation.
  296.  
  297.   // The following coversion operators are needed to support the casting
  298.   // of this var type to a const T* or a T*. The CORBA spec. doesn't say
  299.   // these castings must be supported so they are deliberately left out.
  300.   // In fact, the operator->() can always be used to get to the T*.
  301.   //
  302.   // inline operator const T* () const { return pd_data; }
  303.   // inline operator T* () { return pd_data; }
  304.  
  305.   friend class _CORBA_Sequence_OUT_arg<T,_CORBA_Sequence_Var<T,ElmType> >;
  306.  
  307. private:
  308.   T* pd_data;
  309. };
  310.  
  311. template <class T,class T_slice>
  312. class _CORBA_Sequence_Array_Var {
  313. public:
  314.   typedef T* ptr_t;
  315.   inline _CORBA_Sequence_Array_Var() { pd_data = 0; }
  316.   inline _CORBA_Sequence_Array_Var(T* p) { pd_data = p; }
  317.   inline _CORBA_Sequence_Array_Var(const _CORBA_Sequence_Array_Var<T,T_slice> &p);
  318.   inline ~_CORBA_Sequence_Array_Var() {  if (pd_data) delete pd_data; }
  319.   inline _CORBA_Sequence_Array_Var<T,T_slice> &operator= (T* p);
  320.   inline _CORBA_Sequence_Array_Var<T,T_slice> &operator= (const _CORBA_Sequence_Array_Var<T,T_slice> &p);
  321.   inline T_slice* operator[] (_CORBA_ULong index) { return (T_slice*)((pd_data->NP_data())[index]); }
  322.   inline const T_slice* operator[] (_CORBA_ULong index) const {
  323.     return (const T_slice*)((pd_data->NP_data())[index]);
  324.   }
  325.   inline T* operator->() const { return (T*)pd_data; }
  326.  
  327. #if defined(__GNUG__) && __GNUG__ == 2 && __GNUC_MINOR__ == 7
  328.   inline operator T& () const { return *pd_data; }
  329. #else
  330.   inline operator const T& () const { return *pd_data; }
  331.   inline operator T& () { return *pd_data; }
  332. #endif
  333.   // This conversion operator is necessary to support the implicit conversion
  334.   // when this var type is used as the IN or INOUT argument of an operation.
  335.  
  336.   // The following coversion operators are needed to support the casting
  337.   // of this var type to a const T* or a T*. The CORBA spec. doesn't say
  338.   // these castings must be supported so they are deliberately left out.
  339.   // In fact, the operator->() can always be used to get to the T*.
  340.   //
  341.   // inline operator const T* () const { return pd_data; }
  342.   // inline operator T* () { return pd_data; }
  343.  
  344.   friend class _CORBA_Sequence_OUT_arg<T,_CORBA_Sequence_Array_Var<T,T_slice> >;
  345.  
  346. private:
  347.   T* pd_data;
  348. };
  349.  
  350.  
  351. template <class T, class T_var>
  352. class _CORBA_Sequence_OUT_arg {
  353. public:
  354.   inline _CORBA_Sequence_OUT_arg(T*& p) : _data(p) {}
  355.   inline _CORBA_Sequence_OUT_arg(T_var& p) : _data(p.pd_data) {
  356.     p = (T*)0;
  357.   }
  358.   T*& _data;
  359. private:
  360.   _CORBA_Sequence_OUT_arg();
  361. };
  362.  
  363. template <class T, class T_var>
  364. class _CORBA_Array_OUT_arg;
  365.  
  366. template <class T_Helper,class T>
  367. class _CORBA_Array_Var {
  368. public:
  369.   inline _CORBA_Array_Var () { pd_data = 0; }
  370.   inline _CORBA_Array_Var (T* p) { pd_data = p; }
  371.   inline _CORBA_Array_Var (const _CORBA_Array_Var<T_Helper,T>& p);
  372.   inline ~_CORBA_Array_Var() { if (pd_data) T_Helper::free(pd_data); }
  373.   inline _CORBA_Array_Var<T_Helper,T> &operator= (T* p);
  374.   inline _CORBA_Array_Var<T_Helper,T> &operator= (const _CORBA_Array_Var<T_Helper,T>& p);
  375.   inline T& operator[] (_CORBA_ULong index) { return *(pd_data + index); }
  376.   inline const T& operator[] (_CORBA_ULong index) const { return *( (const T*) (pd_data + index));  }
  377.   inline operator T* () const { return pd_data; }
  378.   // Define the const T* operator() causes conversion operator ambiguity with 
  379.   // some compilers. Should be alright to leave this operator out. If not,
  380.   // reinstate it and #ifdef it with the right compiler specific macro.
  381.   //
  382.   //  inline operator const T* () const { return (const T*) pd_data; }
  383.  
  384.   friend class _CORBA_Array_OUT_arg<T, _CORBA_Array_Var<T_Helper,T> >;
  385.  
  386. private:
  387.   T* pd_data;
  388. };
  389.  
  390. template <class T, class T_var>
  391. class _CORBA_Array_OUT_arg {
  392. public:
  393.   inline _CORBA_Array_OUT_arg(T*& p) : _data(p) {}
  394.   inline _CORBA_Array_OUT_arg(T_var& p) : _data(p.pd_data) {
  395.     p = (T*)0;
  396.   }
  397.   T*& _data;
  398. private:
  399.   _CORBA_Array_OUT_arg();
  400. };
  401.  
  402. template <class T_Helper,class T>
  403. class _CORBA_Array_Forany {
  404. public:
  405.   inline _CORBA_Array_Forany () { pd_data = 0; }
  406.   inline _CORBA_Array_Forany (T* p,_CORBA_Boolean nocopy = 0);
  407.   inline _CORBA_Array_Forany (const _CORBA_Array_Forany<T_Helper,T>& p);
  408.   inline ~_CORBA_Array_Forany() {
  409.     // does not delete the storage of the underlying array
  410.   }
  411.   inline _CORBA_Array_Forany<T_Helper,T> &operator= (T* p);
  412.   inline T& operator[] (_CORBA_ULong index) { return *(pd_data + index); }
  413.   inline const T& operator[] (_CORBA_ULong index) const { return *( (const T*) (pd_data + index)); }
  414.   inline operator T* () const { return pd_data; }
  415.   inline operator const T* () const { return (const T*) pd_data; }
  416.  
  417.   inline T* NP_getSlice() const { return pd_data; }
  418. private:
  419.   T* pd_data;
  420. };
  421.  
  422.  
  423. template <class T,int max>
  424. inline 
  425. _CORBA_Bounded_Sequence<T,max>&
  426. _CORBA_Bounded_Sequence<T,max>::operator= (const _CORBA_Bounded_Sequence<T,max> &s)
  427. {
  428.   _CORBA_Sequence<T>::operator= (s);
  429.   return *this;
  430. }
  431.  
  432. template <class T,int max>
  433. inline 
  434. void
  435. _CORBA_Bounded_Sequence<T,max>::length(_CORBA_ULong len)
  436. {
  437.   if (len > max) {
  438.     _CORBA_bound_check_error();
  439.     // never reach here
  440.   }
  441.   _CORBA_Sequence<T>::length(len);
  442.   return;
  443. }
  444.  
  445. template <class T,class T_slice,class Telm,int dimension,int max>
  446. inline 
  447. _CORBA_Bounded_Sequence_Array<T,T_slice,Telm,dimension,max>&
  448. _CORBA_Bounded_Sequence_Array<T,T_slice,Telm,dimension,max>::operator= (const _CORBA_Bounded_Sequence_Array<T,T_slice,Telm,dimension,max> &s)
  449. {
  450.   _CORBA_Sequence_Array<T,T_slice,Telm,dimension>::operator= (s);
  451.   return *this;
  452. }
  453.  
  454. template <class T,class T_slice,class Telm,int dimension,int max>
  455. inline 
  456. void
  457. _CORBA_Bounded_Sequence_Array<T,T_slice,Telm,dimension,max>::length(_CORBA_ULong len)
  458. {
  459.   if (len > max) {
  460.     _CORBA_bound_check_error();
  461.     // never reach here
  462.   }
  463.   _CORBA_Sequence_Array<T,T_slice,Telm,dimension>::length(len);
  464.   return;
  465. }
  466.  
  467.  
  468. template <class T,int max,int elmSize, int elmAlignment>
  469. inline
  470. _CORBA_Bounded_Sequence_w_FixSizeElement<T,max,elmSize,elmAlignment>&
  471. _CORBA_Bounded_Sequence_w_FixSizeElement<T,max,elmSize,elmAlignment>::operator=(const 
  472. _CORBA_Bounded_Sequence_w_FixSizeElement<T,max,elmSize,elmAlignment>& s) 
  473. {
  474.   _CORBA_Sequence<T>::operator=(s);
  475.   return *this;
  476. }
  477.  
  478. template <class T,int max,int elmSize, int elmAlignment>
  479. inline
  480. _CORBA_ULong
  481. _CORBA_Bounded_Sequence_w_FixSizeElement<T,max,elmSize,elmAlignment>::length() const
  482. { 
  483.   return _CORBA_Sequence<T>::length();
  484. }
  485.  
  486. template <class T,int max,int elmSize, int elmAlignment>
  487. inline
  488. void
  489. _CORBA_Bounded_Sequence_w_FixSizeElement<T,max,elmSize,elmAlignment>::length(_CORBA_ULong len)
  490. {
  491.   if (len > max) {
  492.     _CORBA_bound_check_error();
  493.     // never reach here
  494.   }
  495.   _CORBA_Sequence<T>::length(len);
  496.   return;
  497. }
  498.  
  499. template <class T,class T_slice,class Telm,int dimension,int max,int elmSize, int elmAlignment>
  500. inline
  501. _CORBA_Bounded_Sequence_Array_w_FixSizeElement<T,T_slice,Telm,dimension,max,elmSize,elmAlignment>&
  502. _CORBA_Bounded_Sequence_Array_w_FixSizeElement<T,T_slice,Telm,dimension,max,elmSize,elmAlignment>::operator=(const 
  503. _CORBA_Bounded_Sequence_Array_w_FixSizeElement<T,T_slice,Telm,dimension,max,elmSize,elmAlignment>& s) 
  504. {
  505.   _CORBA_Sequence_Array<T,T_slice,Telm,dimension>::operator=(s);
  506.   return *this;
  507. }
  508.  
  509. template <class T,class T_slice,class Telm,int dimension,int max,int elmSize, int elmAlignment>
  510. inline
  511. _CORBA_ULong
  512. _CORBA_Bounded_Sequence_Array_w_FixSizeElement<T,T_slice,Telm,dimension,max,elmSize,elmAlignment>::length() const
  513. { 
  514.   return _CORBA_Sequence_Array<T,T_slice,Telm,dimension>::length();
  515. }
  516.  
  517. template <class T,class T_slice,class Telm,int dimension,int max,int elmSize, int elmAlignment>
  518. inline
  519. void
  520. _CORBA_Bounded_Sequence_Array_w_FixSizeElement<T,T_slice,Telm,dimension,max,elmSize,elmAlignment>::length(_CORBA_ULong len)
  521. {
  522.   if (len > max) {
  523.     _CORBA_bound_check_error();
  524.     // never reach here
  525.   }
  526.   _CORBA_Sequence_Array<T,T_slice,Telm,dimension>::length(len);
  527.   return;
  528. }
  529.  
  530.  
  531. template <class T,class T_Helper>
  532. inline
  533. _CORBA_ObjRef_Var<T,T_Helper>::_CORBA_ObjRef_Var(const _CORBA_ObjRef_Var<T,T_Helper> &p) 
  534. {
  535.   if (!T_Helper::is_nil(p.pd_objref)) {
  536.     T_Helper::duplicate(p.pd_objref);
  537.     pd_objref = p.pd_objref;
  538.   }
  539.   else
  540.     pd_objref = T_Helper::_nil();
  541. }
  542.  
  543. template <class T,class T_Helper>
  544. inline
  545. _CORBA_ObjRef_Var<T,T_Helper>::_CORBA_ObjRef_Var(const _CORBA_ObjRef_Member<T,T_Helper>& p)
  546. {
  547.   if (!T_Helper::is_nil(p._ptr)) {
  548.     T_Helper::duplicate(p._ptr);
  549.     pd_objref = p._ptr;
  550.   }
  551.   else
  552.     pd_objref = T_Helper::_nil();
  553. }
  554.  
  555. template <class T,class T_Helper>
  556. inline
  557. _CORBA_ObjRef_Var<T,T_Helper> &
  558. _CORBA_ObjRef_Var<T,T_Helper>::operator= (T * p)
  559. {
  560.   if (!T_Helper::is_nil(pd_objref)) T_Helper::release(pd_objref);
  561.   pd_objref = p;
  562.   return *this;
  563. }
  564.  
  565. template <class T,class T_Helper>
  566. inline
  567. _CORBA_ObjRef_Var<T,T_Helper> &
  568. _CORBA_ObjRef_Var<T,T_Helper>::operator= (const _CORBA_ObjRef_Var<T,T_Helper> &p)
  569. {
  570.   if (!T_Helper::is_nil(pd_objref)) T_Helper::release(pd_objref);
  571.   if (!T_Helper::is_nil(p.pd_objref)) {
  572.     T_Helper::duplicate(p.pd_objref);
  573.     pd_objref = p.pd_objref;
  574.   }
  575.   else
  576.     pd_objref = T_Helper::_nil();
  577.   return *this;
  578. }
  579.  
  580. template <class T,class T_Helper>
  581. inline
  582. _CORBA_ObjRef_Var<T,T_Helper> &
  583. _CORBA_ObjRef_Var<T,T_Helper>::operator= (const _CORBA_ObjRef_Member<T,T_Helper>& p)
  584. {
  585.   if (!T_Helper::is_nil(pd_objref)) T_Helper::release(pd_objref);
  586.   if (!T_Helper::is_nil(p._ptr)) {
  587.     T_Helper::duplicate(p._ptr);
  588.     pd_objref = p._ptr;
  589.   }
  590.   else
  591.     pd_objref = T_Helper::_nil();
  592.   return *this;
  593. }
  594.  
  595. template <class T,class T_Helper>
  596. inline 
  597. _CORBA_ObjRef_Member<T,T_Helper>::_CORBA_ObjRef_Member(const _CORBA_ObjRef_Member<T,T_Helper> &p)
  598. {
  599.   if (!T_Helper::is_nil(p._ptr)) {
  600.     T_Helper::duplicate(p._ptr);
  601.     _ptr = p._ptr;
  602.   }
  603.   else
  604.     _ptr = T_Helper::_nil();
  605. }
  606.  
  607. template <class T,class T_Helper>
  608. inline 
  609. _CORBA_ObjRef_Member<T,T_Helper>&
  610. _CORBA_ObjRef_Member<T,T_Helper>::operator= (T * p)
  611. {
  612.   if (!T_Helper::is_nil(_ptr)) T_Helper::release(_ptr);
  613.   _ptr = p;
  614.   return *this;
  615. }
  616.  
  617. template <class T,class T_Helper>
  618. inline 
  619. _CORBA_ObjRef_Member<T,T_Helper>&
  620. _CORBA_ObjRef_Member<T,T_Helper>::operator= (const _CORBA_ObjRef_Member<T,T_Helper> &p)
  621. {
  622.   if (!T_Helper::is_nil(_ptr)) T_Helper::release(_ptr);
  623.   if (!T_Helper::is_nil(p._ptr)) {
  624.     T_Helper::duplicate(p._ptr);
  625.     _ptr = p._ptr;
  626.   }
  627.   else
  628.     _ptr = T_Helper::_nil();
  629.   return *this;
  630. }
  631.  
  632. template <class T,class T_Helper>
  633. inline 
  634. _CORBA_ObjRef_Member<T,T_Helper>&
  635. _CORBA_ObjRef_Member<T,T_Helper>::operator= (const _CORBA_ObjRef_Var<T,T_Helper> &p)
  636. {
  637.   if (!T_Helper::is_nil(_ptr)) T_Helper::release(_ptr);
  638.   if (!T_Helper::is_nil(p.pd_objref)) {
  639.     T_Helper::duplicate(p.pd_objref);
  640.     _ptr = p.pd_objref;
  641.   }
  642.   else
  643.     _ptr = T_Helper::_nil();
  644.   return *this;
  645. }
  646.  
  647. template <class T,class T_Helper>
  648. inline 
  649. size_t 
  650. _CORBA_ObjRef_Member<T,T_Helper>::NP_alignedSize(size_t initialoffset) const 
  651. {
  652.   return T_Helper::NP_alignedSize(_ptr,initialoffset);
  653. }
  654.  
  655. template <class T,class T_Helper>
  656. inline 
  657. void
  658. _CORBA_ObjRef_Member<T,T_Helper>::operator>>= (NetBufferedStream &s) const 
  659. {
  660.   T_Helper::marshalObjRef(_ptr,s);
  661. }
  662.  
  663. template <class T,class T_Helper>
  664. inline 
  665. void
  666. _CORBA_ObjRef_Member<T,T_Helper>::operator<<= (NetBufferedStream &s)
  667. {
  668.   T* _result = T_Helper::unmarshalObjRef(s);
  669.   T_Helper::release(_ptr);
  670.   _ptr = _result;
  671. }
  672.  
  673. template <class T,class T_Helper>
  674. inline 
  675. void
  676. _CORBA_ObjRef_Member<T,T_Helper>::operator>>= (MemBufferedStream &s) const
  677. {
  678.   T_Helper::marshalObjRef(_ptr,s);
  679. }
  680.  
  681. template <class T,class T_Helper>
  682. inline 
  683. void
  684. _CORBA_ObjRef_Member<T,T_Helper>::operator<<= (MemBufferedStream &s)
  685. {
  686.   T* _result = T_Helper::unmarshalObjRef(s);
  687.   T_Helper::release(_ptr);
  688.   _ptr = _result;
  689. }
  690.  
  691. template <class T>
  692. inline 
  693. _CORBA_ConstrType_Variable_Var<T>::_CORBA_ConstrType_Variable_Var(const _CORBA_ConstrType_Variable_Var<T> &p) 
  694. {
  695.   if (!p.pd_data) {
  696.     pd_data = 0;
  697.     return;
  698.   }
  699.   else {
  700.     pd_data = new T;
  701.     if (!pd_data) {
  702.       _CORBA_new_operator_return_null();
  703.       // never reach here
  704.     }
  705.     *pd_data = *p.pd_data;
  706.   }
  707. }
  708.  
  709. template <class T>
  710. inline
  711. _CORBA_ConstrType_Variable_Var<T> &
  712. _CORBA_ConstrType_Variable_Var<T>::operator= (T* p)
  713. {
  714.   if (pd_data) delete pd_data;
  715.   pd_data = p;
  716.   return *this;
  717. }
  718.  
  719. template <class T>
  720. inline
  721. _CORBA_ConstrType_Variable_Var<T> &
  722. _CORBA_ConstrType_Variable_Var<T>::operator= (const _CORBA_ConstrType_Variable_Var<T> &p)
  723. {
  724.   if (p.pd_data) {
  725.     if (!pd_data) {
  726.       pd_data = new T;
  727.       if (!pd_data) {
  728.     _CORBA_new_operator_return_null();
  729.     // never reach here
  730.       }
  731.     }
  732.     *pd_data = *p.pd_data;
  733.   }
  734.   else {
  735.     if (pd_data) delete pd_data;
  736.     pd_data = 0;
  737.   }
  738.   return *this;
  739. }
  740.  
  741. template <class T,class ElmType>
  742. inline
  743. _CORBA_Sequence_Var<T,ElmType> &
  744. _CORBA_Sequence_Var<T,ElmType>::operator= (const _CORBA_Sequence_Var<T,ElmType> &p)
  745. {
  746.   if (p.pd_data) {
  747.     if (!pd_data) {
  748.       pd_data = new T;
  749.       if (!pd_data) {
  750.     _CORBA_new_operator_return_null();
  751.     // never reach here
  752.       }
  753.     }
  754.     *pd_data = *p.pd_data;
  755.   }
  756.   else {
  757.     if (pd_data) delete pd_data;
  758.     pd_data = 0;
  759.   }
  760.   return *this;
  761. }
  762.  
  763. template <class T,class ElmType>
  764. inline 
  765. _CORBA_Sequence_Var<T,ElmType>::_CORBA_Sequence_Var(const _CORBA_Sequence_Var<T,ElmType> &p) 
  766. {
  767.   if (!p.pd_data) {
  768.     pd_data = 0;
  769.     return;
  770.   }
  771.   else {
  772.     pd_data = new T;
  773.     if (!pd_data) {
  774.       _CORBA_new_operator_return_null();
  775.       // never reach here
  776.     }
  777.     *pd_data = *p.pd_data;
  778.   }
  779. }
  780.  
  781. template <class T,class ElmType>
  782. inline
  783. _CORBA_Sequence_Var<T,ElmType> &
  784. _CORBA_Sequence_Var<T,ElmType>::operator= (T* p)
  785. {
  786.   if (pd_data) delete pd_data;
  787.   pd_data = p;
  788.   return *this;
  789. }
  790.  
  791. template <class T,class T_slice>
  792. inline
  793. _CORBA_Sequence_Array_Var<T,T_slice> &
  794. _CORBA_Sequence_Array_Var<T,T_slice>::operator= (const _CORBA_Sequence_Array_Var<T,T_slice> &p)
  795. {
  796.   if (p.pd_data) {
  797.     if (!pd_data) {
  798.       pd_data = new T;
  799.       if (!pd_data) {
  800.     _CORBA_new_operator_return_null();
  801.     // never reach here
  802.       }
  803.     }
  804.     *pd_data = *p.pd_data;
  805.   }
  806.   else {
  807.     if (pd_data) delete pd_data;
  808.     pd_data = 0;
  809.   }
  810.   return *this;
  811. }
  812.  
  813. template <class T,class T_slice>
  814. inline 
  815. _CORBA_Sequence_Array_Var<T,T_slice>::_CORBA_Sequence_Array_Var(const _CORBA_Sequence_Array_Var<T,T_slice> &p) 
  816. {
  817.   if (!p.pd_data) {
  818.     pd_data = 0;
  819.     return;
  820.   }
  821.   else {
  822.     pd_data = new T;
  823.     if (!pd_data) {
  824.       _CORBA_new_operator_return_null();
  825.       // never reach here
  826.     }
  827.     *pd_data = *p.pd_data;
  828.   }
  829. }
  830.  
  831. template <class T,class T_slice>
  832. inline
  833. _CORBA_Sequence_Array_Var<T,T_slice> &
  834. _CORBA_Sequence_Array_Var<T,T_slice>::operator= (T* p)
  835. {
  836.   if (pd_data) delete pd_data;
  837.   pd_data = p;
  838.   return *this;
  839. }
  840.  
  841.  
  842. template <class T_Helper,class T>
  843. inline
  844. _CORBA_Array_Var<T_Helper,T>::_CORBA_Array_Var (const _CORBA_Array_Var<T_Helper,T >& p) 
  845. {
  846.   if (!p.pd_data) {
  847.     pd_data = 0;
  848.   }
  849.   else {
  850.     pd_data = T_Helper::dup(p.pd_data);
  851.     if (!pd_data) {
  852.       _CORBA_new_operator_return_null();
  853.     }
  854.   }
  855. }
  856.  
  857. template <class T_Helper,class T>
  858. inline 
  859. _CORBA_Array_Var<T_Helper,T>&
  860. _CORBA_Array_Var<T_Helper,T>::operator= (T* p) 
  861. {
  862.   if (pd_data) T_Helper::free(pd_data);
  863.   pd_data = p;
  864.   return *this;
  865. }
  866.  
  867. template <class T_Helper,class T>
  868. inline 
  869. _CORBA_Array_Var<T_Helper,T>&
  870. _CORBA_Array_Var<T_Helper,T>::operator= (const _CORBA_Array_Var<T_Helper,T>& p) 
  871. {
  872.   if (pd_data) {
  873.     T_Helper::free(pd_data);
  874.   }
  875.   if (p.pd_data) {
  876.     pd_data = T_Helper::dup(p.pd_data);
  877.     if (!pd_data) {
  878.       _CORBA_new_operator_return_null();
  879.       // never reach here
  880.     }
  881.   }
  882.   else {
  883.     pd_data = 0;
  884.   }
  885.   return *this;
  886. }
  887.  
  888. template <class T_Helper,class T>
  889. inline 
  890. _CORBA_Array_Forany<T_Helper,T>::_CORBA_Array_Forany (T* p,_CORBA_Boolean nocopy)
  891. {
  892.   if (nocopy) {
  893.     pd_data = p;
  894.   }
  895.   else {
  896.     if (p) {
  897.       pd_data = T_Helper::dup(p);
  898.       if (!pd_data) {
  899.     _CORBA_new_operator_return_null();
  900.     // never reach here
  901.       }
  902.     }
  903.     else {
  904.       pd_data = 0;
  905.     }
  906.   }
  907. }
  908.  
  909.  
  910. template <class T_Helper,class T>
  911. inline 
  912. _CORBA_Array_Forany<T_Helper,T>&
  913. _CORBA_Array_Forany<T_Helper,T>::operator= (T* p) 
  914. {
  915.   pd_data = p;
  916.   return *this;
  917. }
  918.  
  919. template <class T_Helper,class T>
  920. inline 
  921. _CORBA_Array_Forany<T_Helper,T>::_CORBA_Array_Forany (const _CORBA_Array_Forany<T_Helper,T>& p)
  922. {
  923.   if (!p.pd_data) {
  924.     pd_data = 0;
  925.   }
  926.   else {
  927.     pd_data = T_Helper::dup(p.pd_data);
  928.     if (!pd_data) {
  929.       _CORBA_new_operator_return_null();
  930.     }
  931.   }
  932. }
  933.  
  934. #endif // __TEMPLATES_H__
  935.  
  936.